home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2008 February / PCWFEB08.iso / Software / Resources / Developers / XAMPP 1.5.4 / Windows installer / xampp-win32-1.5.4-installer.exe / xampp / php / pear / Mail.php < prev    next >
Encoding:
PHP Script  |  2005-09-26  |  7.9 KB  |  212 lines
  1. <?php
  2. //
  3. // +----------------------------------------------------------------------+
  4. // | PHP Version 4                                                        |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997-2003 The PHP Group                                |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 2.02 of the PHP license,      |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/2_02.txt.                                 |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Author: Chuck Hagenbuch <chuck@horde.org>                            |
  17. // +----------------------------------------------------------------------+
  18. //
  19. // $Id: Mail.php,v 1.12 2005/08/22 01:19:27 jon Exp $
  20.  
  21. require_once 'PEAR.php';
  22.  
  23. /**
  24.  * PEAR's Mail:: interface. Defines the interface for implementing
  25.  * mailers under the PEAR hierarchy, and provides supporting functions
  26.  * useful in multiple mailer backends.
  27.  *
  28.  * @access public
  29.  * @version $Revision: 1.12 $
  30.  * @package Mail
  31.  */
  32. class Mail
  33. {
  34.     /**
  35.      * Line terminator used for separating header lines.
  36.      * @var string
  37.      */
  38.     var $sep = "\r\n";
  39.  
  40.     /**
  41.      * Provides an interface for generating Mail:: objects of various
  42.      * types
  43.      *
  44.      * @param string $driver The kind of Mail:: object to instantiate.
  45.      * @param array  $params The parameters to pass to the Mail:: object.
  46.      * @return object Mail a instance of the driver class or if fails a PEAR Error
  47.      * @access public
  48.      */
  49.     function &factory($driver, $params = array())
  50.     {
  51.         $driver = strtolower($driver);
  52.         @include_once 'Mail/' . $driver . '.php';
  53.         $class = 'Mail_' . $driver;
  54.         if (class_exists($class)) {
  55.             $mailer = new $class($params);
  56.             return $mailer;
  57.         } else {
  58.             return PEAR::raiseError('Unable to find class for driver ' . $driver);
  59.         }
  60.     }
  61.  
  62.     /**
  63.      * Implements Mail::send() function using php's built-in mail()
  64.      * command.
  65.      *
  66.      * @param mixed $recipients Either a comma-seperated list of recipients
  67.      *              (RFC822 compliant), or an array of recipients,
  68.      *              each RFC822 valid. This may contain recipients not
  69.      *              specified in the headers, for Bcc:, resending
  70.      *              messages, etc.
  71.      *
  72.      * @param array $headers The array of headers to send with the mail, in an
  73.      *              associative array, where the array key is the
  74.      *              header name (ie, 'Subject'), and the array value
  75.      *              is the header value (ie, 'test'). The header
  76.      *              produced from those values would be 'Subject:
  77.      *              test'.
  78.      *
  79.      * @param string $body The full text of the message body, including any
  80.      *               Mime parts, etc.
  81.      *
  82.      * @return mixed Returns true on success, or a PEAR_Error
  83.      *               containing a descriptive error message on
  84.      *               failure.
  85.      * @access public
  86.      * @deprecated use Mail_mail::send instead
  87.      */
  88.     function send($recipients, $headers, $body)
  89.     {
  90.         // if we're passed an array of recipients, implode it.
  91.         if (is_array($recipients)) {
  92.             $recipients = implode(', ', $recipients);
  93.         }
  94.  
  95.         // get the Subject out of the headers array so that we can
  96.         // pass it as a seperate argument to mail().
  97.         $subject = '';
  98.         if (isset($headers['Subject'])) {
  99.             $subject = $headers['Subject'];
  100.             unset($headers['Subject']);
  101.         }
  102.  
  103.         // flatten the headers out.
  104.         list(,$text_headers) = Mail::prepareHeaders($headers);
  105.  
  106.         return mail($recipients, $subject, $body, $text_headers);
  107.  
  108.     }
  109.  
  110.     /**
  111.      * Take an array of mail headers and return a string containing
  112.      * text usable in sending a message.
  113.      *
  114.      * @param array $headers The array of headers to prepare, in an associative
  115.      *              array, where the array key is the header name (ie,
  116.      *              'Subject'), and the array value is the header
  117.      *              value (ie, 'test'). The header produced from those
  118.      *              values would be 'Subject: test'.
  119.      *
  120.      * @return mixed Returns false if it encounters a bad address,
  121.      *               otherwise returns an array containing two
  122.      *               elements: Any From: address found in the headers,
  123.      *               and the plain text version of the headers.
  124.      * @access private
  125.      */
  126.     function prepareHeaders($headers)
  127.     {
  128.         $lines = array();
  129.         $from = null;
  130.  
  131.         foreach ($headers as $key => $value) {
  132.             if (strcasecmp($key, 'From') === 0) {
  133.                 include_once 'Mail/RFC822.php';
  134.                 $parser = &new Mail_RFC822();
  135.                 $addresses = $parser->parseAddressList($value, 'localhost', false);
  136.                 if (PEAR::isError($addresses)) {
  137.                     return $addresses;
  138.                 }
  139.  
  140.                 $from = $addresses[0]->mailbox . '@' . $addresses[0]->host;
  141.  
  142.                 // Reject envelope From: addresses with spaces.
  143.                 if (strstr($from, ' ')) {
  144.                     return false;
  145.                 }
  146.  
  147.                 $lines[] = $key . ': ' . $value;
  148.             } elseif (strcasecmp($key, 'Received') === 0) {
  149.                 $received = array();
  150.                 if (is_array($value)) {
  151.                     foreach ($value as $line) {
  152.                         $received[] = $key . ': ' . $line;
  153.                     }
  154.                 }
  155.                 else {
  156.                     $received[] = $key . ': ' . $value;
  157.                 }
  158.                 // Put Received: headers at the top.  Spam detectors often
  159.                 // flag messages with Received: headers after the Subject:
  160.                 // as spam.
  161.                 $lines = array_merge($received, $lines);
  162.             } else {
  163.                 // If $value is an array (i.e., a list of addresses), convert
  164.                 // it to a comma-delimited string of its elements (addresses).
  165.                 if (is_array($value)) {
  166.                     $value = implode(', ', $value);
  167.                 }
  168.                 $lines[] = $key . ': ' . $value;
  169.             }
  170.         }
  171.  
  172.         return array($from, join($this->sep, $lines) . $this->sep);
  173.     }
  174.  
  175.     /**
  176.      * Take a set of recipients and parse them, returning an array of
  177.      * bare addresses (forward paths) that can be passed to sendmail
  178.      * or an smtp server with the rcpt to: command.
  179.      *
  180.      * @param mixed Either a comma-seperated list of recipients
  181.      *              (RFC822 compliant), or an array of recipients,
  182.      *              each RFC822 valid.
  183.      *
  184.      * @return array An array of forward paths (bare addresses).
  185.      * @access private
  186.      */
  187.     function parseRecipients($recipients)
  188.     {
  189.         include_once 'Mail/RFC822.php';
  190.  
  191.         // if we're passed an array, assume addresses are valid and
  192.         // implode them before parsing.
  193.         if (is_array($recipients)) {
  194.             $recipients = implode(', ', $recipients);
  195.         }
  196.  
  197.         // Parse recipients, leaving out all personal info. This is
  198.         // for smtp recipients, etc. All relevant personal information
  199.         // should already be in the headers.
  200.         $addresses = Mail_RFC822::parseAddressList($recipients, 'localhost', false);
  201.         $recipients = array();
  202.         if (is_array($addresses)) {
  203.             foreach ($addresses as $ob) {
  204.                 $recipients[] = $ob->mailbox . '@' . $ob->host;
  205.             }
  206.         }
  207.  
  208.         return $recipients;
  209.     }
  210.  
  211. }
  212.